"""
命令行界面模块
提供命令行方式使用视频转录和摘要功能
"""

import argparse
import logging
import sys
from pathlib import Path
import os

from .video_processor import VideoProcessor
from .transcriber import WhisperTranscriber
from .summarizer import VideoSummarizer
from .ollama_client import OllamaClient
from .output_formatter import OutputFormatter
from .utils import setup_logging, format_duration, format_file_size

def create_parser() -> argparse.ArgumentParser:
    """创建命令行参数解析器"""
    parser = argparse.ArgumentParser(
        description="本地智能视频摘要工具 - 基于OpenAI Whisper和Ollama的视频摘要",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=f"""
示例用法:
  # 单文件处理
  %(prog)s -i video.mp4 -o summary.md --format md

  # 批量处理
  %(prog)s --batch --input-dir /path/to/videos --output-dir /path/to/summaries

  # 更多选项
  %(prog)s -i video.mp4 -m medium -l zh --summary-style bullet_points
        """)

    # 输入输出参数
    input_group = parser.add_argument_group('输入选项')
    input_group.add_argument('-i', '--input', help='输入视频文件路径（单文件模式）')
    input_group.add_argument('--input-dir', help='输入视频目录（批量模式）')

    output_group = parser.add_argument_group('输出选项')
    output_group.add_argument('-o', '--output', help='输出文件路径（单文件模式）')
    output_group.add_argument('--output-dir', help='输出目录（批量模式）')

    # 模式选择
    parser.add_argument('--batch', action='store_true', help='启用批量处理模式')

    # 模型参数
    model_group = parser.add_argument_group('AI模型设置')
    model_group.add_argument('-m', '--model', default='base',
                       choices=['tiny', 'base', 'small', 'medium', 'large', 'large-v2', 'large-v3'],
                       help='Whisper模型大小 (默认: base)')
    model_group.add_argument('-l', '--language', default='auto',
                       help='语言代码 (如: zh, en, auto) (默认: auto)')
    model_group.add_argument('--ollama-model', default='qwen2:7b', help='Ollama模型名称 (默认: qwen2:7b)')

    # 摘要设置
    summary_group = parser.add_argument_group('摘要设置')
    summary_group.add_argument('--summary-style', default='detailed', choices=['concise', 'detailed', 'bullet_points'], help='摘要风格 (默认: detailed)')
    summary_group.add_argument('--no-summary', action='store_true', help='仅执行转录，不生成摘要')

    # 输出格式
    format_group = parser.add_argument_group('输出格式')
    format_group.add_argument('-f', '--format', default='md',
                       choices=['txt', 'srt', 'vtt', 'json', 'md', 'html', 'mm'],
                       help='输出格式 (默认: md)')

    # 其他选项
    other_group = parser.add_argument_group('其他选项')
    other_group.add_argument('--device', choices=['auto', 'cpu', 'cuda'], default='auto',
                       help='处理设备 (默认: auto)')
    other_group.add_argument('--no-cleanup', action='store_true', help='不清理临时文件')
    other_group.add_argument('-v', '--verbose', action='store_true', help='详细输出')

    return parser

def process_file(input_path: Path, output_path: Path, args):
    """处理单个文件"""
    logger = logging.getLogger(__name__)
    print(f"\n---\n🔄 开始处理文件: {input_path.name}")

    try:
        video_processor = VideoProcessor()
        if not video_processor.is_supported_format(str(input_path)):
            logger.warning(f"跳过不支持的文件格式: {input_path.name}")
            return

        # 提取音频
        logger.info("正在提取音频...")
        audio_path = video_processor.extract_audio(str(input_path))
        temp_files = [audio_path]

        # 初始化转录器和摘要器
        device = args.device if args.device != 'auto' else None
        transcriber = WhisperTranscriber(args.model, device)
        summarizer = None if args.no_summary else VideoSummarizer(OllamaClient(), args.ollama_model)

        # 转录
        logger.info("正在转录...")
        transcript_result = transcriber.transcribe_audio(
            audio_path, args.language if args.language != 'auto' else None
        )

        # 摘要
        if summarizer:
            logger.info("正在生成摘要...")
            summary_result = summarizer.generate_summary(
                transcript_result['text'],
                style=args.summary_style,
                language=transcript_result.get('language', 'en')
            )
        else:
            summary_result = None

        # 格式化并保存输出
        logger.info("正在保存结果...")
        formatter = OutputFormatter()
        final_result = {
            'transcript': transcript_result,
            'summary': summary_result,
            'video_info': video_processor.get_video_info(str(input_path))
        }
        formatter.save_result(final_result, str(output_path), args.format)
        print(f"✅ 处理完成, 已保存到: {output_path}")

        # 清理
        if not args.no_cleanup:
            video_processor.cleanup_temp_files(temp_files)

    except Exception as e:
        logger.error(f"处理文件 {input_path.name} 时出错: {e}")
        if args.verbose:
            import traceback
            traceback.print_exc()

def main():
    """主函数"""
    parser = create_parser()
    args = parser.parse_args()

    # 设置日志
    log_level = 'DEBUG' if args.verbose else 'INFO'
    setup_logging(log_level)
    logger = logging.getLogger(__name__)

    if args.batch:
        # 批量处理模式
        if not args.input_dir or not args.output_dir:
            logger.error("批量模式下必须同时提供 --input-dir 和 --output-dir")
            sys.exit(1)

        input_dir = Path(args.input_dir)
        output_dir = Path(args.output_dir)

        if not input_dir.is_dir():
            logger.error(f"输入目录不存在: {input_dir}")
            sys.exit(1)

        output_dir.mkdir(parents=True, exist_ok=True)

        video_processor = VideoProcessor()
        files_to_process = [f for f in input_dir.glob('*') if f.is_file() and video_processor.is_supported_format(str(f))]

        if not files_to_process:
            print("在输入目录中未找到支持的视频文件。")
            return

        print(f"找到 {len(files_to_process)} 个文件，开始批量处理...")

        for file_path in files_to_process:
            output_filename = file_path.stem + f'.{args.format}'
            output_path = output_dir / output_filename
            process_file(file_path, output_path, args)

        print("\n---\n🎉 批量处理全部完成！")

    else:
        # 单文件处理模式
        if not args.input:
            logger.error("单文件模式下必须提供 --input 参数")
            parser.print_help()
            sys.exit(1)

        input_path = Path(args.input)
        if args.output:
            output_path = Path(args.output)
        else:
            output_path = input_path.with_suffix(f'.{args.format}')
        
        output_path.parent.mkdir(parents=True, exist_ok=True)
        process_file(input_path, output_path, args)

if __name__ == '__main__':
    main()